{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [],
   "source": [
    "import warnings\n",
    "# Ignore numpy dtype warnings. These warnings are caused by an interaction\n",
    "# between numpy and Cython and can be safely ignored.\n",
    "# Reference: https://stackoverflow.com/a/40846742\n",
    "warnings.filterwarnings(\"ignore\", message=\"numpy.dtype size changed\")\n",
    "warnings.filterwarnings(\"ignore\", message=\"numpy.ufunc size changed\")\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "%matplotlib inline\n",
    "import ipywidgets as widgets\n",
    "from ipywidgets import interact, interactive, fixed, interact_manual\n",
    "import nbinteract as nbi\n",
    "\n",
    "sns.set()\n",
    "sns.set_context('talk')\n",
    "np.set_printoptions(threshold=20, precision=2, suppress=True)\n",
    "pd.options.display.max_rows = 7\n",
    "pd.options.display.max_columns = 8\n",
    "pd.set_option('precision', 2)\n",
    "# This option stops scientific notation for pandas\n",
    "# pd.set_option('display.float_format', '{:.2f}'.format)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [],
   "source": [
    "def df_interact(df, nrows=7, ncols=7):\n",
    "    '''\n",
    "    Outputs sliders that show rows and columns of df\n",
    "    '''\n",
    "    def peek(row=0, col=0):\n",
    "        return df.iloc[row:row + nrows, col:col + ncols]\n",
    "    if len(df.columns) <= ncols:\n",
    "        interact(peek, row=(0, len(df) - nrows, nrows), col=fixed(0))\n",
    "    else:\n",
    "        interact(peek,\n",
    "                 row=(0, len(df) - nrows, nrows),\n",
    "                 col=(0, len(df.columns) - ncols))\n",
    "    print('({} rows, {} columns) total'.format(df.shape[0], df.shape[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true,
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [],
   "source": [
    "df = pd.read_csv('water_large.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [],
   "source": [
    "from collections import namedtuple\n",
    "Curve = namedtuple('Curve', ['xs', 'ys'])\n",
    "\n",
    "def flatten(seq): return [item for subseq in seq for item in subseq]\n",
    "\n",
    "def make_curve(clf, x_start=-50, x_end=50):\n",
    "    xs = np.linspace(x_start, x_end, num=100)\n",
    "    ys = clf.predict(xs.reshape(-1, 1))\n",
    "    return Curve(xs, ys)\n",
    "\n",
    "def plot_data(df=df, ax=plt, **kwargs):\n",
    "    ax.scatter(df.iloc[:, 0], df.iloc[:, 1], s=50, **kwargs)\n",
    "\n",
    "def plot_curve(curve, ax=plt, **kwargs):\n",
    "    ax.plot(curve.xs, curve.ys, **kwargs)\n",
    "    \n",
    "def plot_curves(curves, cols=2, labels=None):\n",
    "    if labels is None:\n",
    "        labels = [f'Deg {deg} poly' for deg in degrees]\n",
    "    rows = int(np.ceil(len(curves) / cols))\n",
    "    fig, axes = plt.subplots(rows, cols, figsize=(10, 8),\n",
    "                             sharex=True, sharey=True)\n",
    "    for ax, curve, label in zip(flatten(axes), curves, labels):\n",
    "        plot_data(ax=ax, label='Training data')\n",
    "        plot_curve(curve, ax=ax, label=label)\n",
    "        ax.set_ylim(-5e10, 170e10)\n",
    "        ax.legend()\n",
    "        \n",
    "    # add a big axes, hide frame\n",
    "    fig.add_subplot(111, frameon=False)\n",
    "    # hide tick and tick label of the big axes\n",
    "    plt.tick_params(labelcolor='none', top='off', bottom='off',\n",
    "                    left='off', right='off')\n",
    "    plt.grid(False)\n",
    "    plt.title('Polynomial Regression')\n",
    "    plt.xlabel('Water Level Change (m)')\n",
    "    plt.ylabel('Water Flow (Liters)')\n",
    "    plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [],
   "source": [
    "def coefs(clf):\n",
    "    reg = clf.named_steps['reg']\n",
    "    return np.append(reg.intercept_, reg.coef_)\n",
    "\n",
    "def coef_table(clf):\n",
    "    vals = coefs(clf)\n",
    "    return (pd.DataFrame({'Coefficient Value': vals})\n",
    "            .rename_axis('degree'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [],
   "source": [
    "X = df.iloc[:, [0]].as_matrix()\n",
    "y = df.iloc[:, 1].as_matrix()\n",
    "\n",
    "degrees = [1, 2, 8, 12]\n",
    "clfs = [Pipeline([('poly', PolynomialFeatures(degree=deg, include_bias=False)),\n",
    "                  ('reg', LinearRegression())])\n",
    "        .fit(X, y)\n",
    "        for deg in degrees]\n",
    "\n",
    "curves = [make_curve(clf) for clf in clfs]\n",
    "\n",
    "alphas = [0.1, 1.0, 10.0]\n",
    "\n",
    "ridge_clfs = [Pipeline([('poly', PolynomialFeatures(degree=deg, include_bias=False)),\n",
    "                        ('reg', RidgeCV(alphas=alphas, normalize=True))])\n",
    "        .fit(X, y)\n",
    "        for deg in degrees]\n",
    "\n",
    "ridge_curves = [make_curve(clf) for clf in ridge_clfs]\n",
    "\n",
    "lasso_clfs = [Pipeline([('poly', PolynomialFeatures(degree=deg, include_bias=False)),\n",
    "                        ('reg', LassoCV(normalize=True, precompute=True, tol=0.001))])\n",
    "        .fit(X, y)\n",
    "        for deg in degrees]\n",
    "lasso_curves = [make_curve(clf) for clf in lasso_clfs]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# L1 Regularization: Lasso Regression\n",
    "\n",
    "In this section we introduce $ L_1 $ regularization, another regularization technique that is useful for feature selection.\n",
    "\n",
    "We start with a brief review of $ L_2 $ regularization for linear regression. We use the model:\n",
    "\n",
    "$$\n",
    "f_\\hat{\\theta}(x) = \\hat{\\theta} \\cdot x\n",
    "$$\n",
    "\n",
    "We fit the model by minimizing the mean squared error cost function with an additional regularization term:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "L(\\hat{\\theta}, X, y)\n",
    "&= \\frac{1}{n} \\sum_{i}(y_i - f_\\hat{\\theta} (X_i))^2\n",
    "    + \\lambda \\sum_{j = 1}^{p} \\hat{\\theta_j}^2\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "In the above definitions, $ X $ represents the $ n \\times p $ data matrix, $ x $ represents a row of $ X $, $ y $ represents the observed outcomes, $ \\hat{\\theta} $ represents the model weights, and $ \\lambda $ represents the regularization parameter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## L1 Regularization Definition\n",
    "\n",
    "To add $ L_1 $ regularization to the model, we modify the cost function above:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "L(\\hat{\\theta}, X, y)\n",
    "&= \\frac{1}{n} \\sum_{i}(y_i - f_\\hat{\\theta} (X_i))^2\n",
    "    + \\lambda \\sum_{j = 1}^{p} |\\hat{\\theta_j}|\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "Observe that the two cost functions only differ in their regularization term. $ L_1 $ regularization penalizes the sum of the absolute weight values instead of the sum of squared values.\n",
    "\n",
    "Using $ L_1 $ regularization with a linear model and the mean squared error cost function is also known more commonly as **lasso regression**. (Lasso stands for Least Absolute Shrinkage and Selection Operator.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparing Lasso and Ridge Regression\n",
    "\n",
    "To conduct lasso regression, we make use of `scikit-learn`'s convenient [`LassoCV`](http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LassoCV.html) classifier, a version of the [`Lasso`](http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Lasso.html) classifier that performs cross-validation to select the regularization parameter. Below, we display our dataset of water level change and water flow out of a dam."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>water_level_change</th>\n",
       "      <th>water_flow</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-15.94</td>\n",
       "      <td>60422330445.52</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-29.15</td>\n",
       "      <td>33214896575.60</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>36.19</td>\n",
       "      <td>972706380901.06</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>7.09</td>\n",
       "      <td>236352046523.78</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>46.28</td>\n",
       "      <td>1494256381086.73</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>14.61</td>\n",
       "      <td>378146284247.97</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>23 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "    water_level_change       water_flow\n",
       "0               -15.94   60422330445.52\n",
       "1               -29.15   33214896575.60\n",
       "2                36.19  972706380901.06\n",
       "..                 ...              ...\n",
       "20                7.09  236352046523.78\n",
       "21               46.28 1494256381086.73\n",
       "22               14.61  378146284247.97\n",
       "\n",
       "[23 rows x 2 columns]"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the procedure is almost identical to using the `RidgeCV` classifier from the previous section, we omit the code and instead display the base degree 12 polynomial, ridge regression, and lasso regression model predictions below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10a763208>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(10, 4))\n",
    "\n",
    "plt.subplot(131)\n",
    "plot_data()\n",
    "plot_curve(curves[3])\n",
    "plt.title('Base')\n",
    "plt.ylim(-5e10, 170e10)\n",
    "\n",
    "plt.subplot(132)\n",
    "plot_data()\n",
    "plot_curve(ridge_curves[3])\n",
    "plt.title('Ridge Regression')\n",
    "plt.ylim(-5e10, 170e10)\n",
    "\n",
    "plt.subplot(133)\n",
    "plot_data()\n",
    "plot_curve(lasso_curves[3])\n",
    "plt.title('Lasso Regression')\n",
    "plt.ylim(-5e10, 170e10)\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that both regularized models have less variance than the base degree 12 polynomial. At a glance, it appears that using $ L_2 $ and $ L_1 $ regularization produces nearly identical models. Comparing the coefficients of ridge and lasso regression, however, reveals the most significant difference between the two types of regularization: the lasso regression model sets a number of model weights to zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Ridge</th>\n",
       "      <th>Lasso</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>degree</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>221303288116.2275085449</td>\n",
       "      <td>198212062407.2835693359</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>6953405307.7653837204</td>\n",
       "      <td>9655088668.0876655579</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>142621063.9297277331</td>\n",
       "      <td>198852674.1646585464</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1893283.0567885502</td>\n",
       "      <td>0.0000000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>38202.1520293704</td>\n",
       "      <td>34434.3458919188</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>484.4262914111</td>\n",
       "      <td>975.6965959434</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>8.1525126516</td>\n",
       "      <td>0.0000000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>0.1197232472</td>\n",
       "      <td>0.0887942172</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>0.0012506185</td>\n",
       "      <td>0.0000000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>0.0000289599</td>\n",
       "      <td>0.0000000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>-0.0000000004</td>\n",
       "      <td>0.0000000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>0.0000000069</td>\n",
       "      <td>0.0000000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>-0.0000000001</td>\n",
       "      <td>-0.0000000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                         Ridge                   Lasso\n",
       "degree                                                \n",
       "0      221303288116.2275085449 198212062407.2835693359\n",
       "1        6953405307.7653837204   9655088668.0876655579\n",
       "2         142621063.9297277331    198852674.1646585464\n",
       "3           1893283.0567885502            0.0000000000\n",
       "4             38202.1520293704        34434.3458919188\n",
       "5               484.4262914111          975.6965959434\n",
       "6                 8.1525126516            0.0000000000\n",
       "7                 0.1197232472            0.0887942172\n",
       "8                 0.0012506185            0.0000000000\n",
       "9                 0.0000289599            0.0000000000\n",
       "10               -0.0000000004            0.0000000000\n",
       "11                0.0000000069            0.0000000000\n",
       "12               -0.0000000001           -0.0000000000"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ridge = coef_table(ridge_clfs[3]).rename(columns={'Coefficient Value': 'Ridge'})\n",
    "lasso = coef_table(lasso_clfs[3]).rename(columns={'Coefficient Value': 'Lasso'})\n",
    "\n",
    "pd.options.display.max_rows = 20\n",
    "pd.set_option('display.float_format', '{:.10f}'.format)\n",
    "display(ridge.join(lasso))\n",
    "pd.options.display.max_rows = 7\n",
    "pd.set_option('display.float_format', '{:.2f}'.format)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you will forgive the verbose output above, you will notice that ridge regression results in non-zero weights for the all polynomial features. Lasso regression, on the other hand, produces weights of zero for seven features.\n",
    "\n",
    "In other words, the lasso regression model completely tosses out a majority of the features when making predictions. Nonetheless, the plots above show that the lasso regression model will make nearly identical predictions compared to the ridge regression model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature Selection with Lasso Regression\n",
    "\n",
    "Lasso regression performs **feature selection**—it discards a subset of the original features when fitting model parameters. This is particularly useful when working with high-dimensional data with many features. A model that only uses a few features to make a prediction will run much faster than a model that requires many calculations. Since unneeded features tend to increase model variance without decreasing bias, we can sometimes increase the accuracy of other models by using lasso regression to select a subset of features to use."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lasso vs. Ridge In Practice\n",
    "\n",
    "If our goal is merely to achieve the highest prediction accuracy, we can try both types of regularization and use cross-validation to select between the two types.\n",
    "\n",
    "Sometimes we prefer one type of regularization over the other because it maps more closely to the domain we are working with. For example, if know that the phenomenon we are trying to model results from many small factors, we might prefer ridge regression because it won't discard these factors. On the other hand, some outcomes result from a few highly influential features. We prefer lasso regression in these situations because it will discard unneeded features."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "Using $ L_1 $ regularization, like $ L_2 $ regularization, allows us to tune model bias and variance by penalizing large model weights. $ L_1 $ regularization for least squares linear regression is also known by the more common name lasso regression. Lasso regression may also be used to perform feature selection since it discards insignificant features."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": false,
   "sideBar": false,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
